#include <algorithm>
#include <deque>
#include <iostream>
#include <istream>
#include <vector>

using namespace std;
using ll = long long;

const int maxapple = 10000;

int main() {
    iostream::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    ll n, W, B, X;
    cin >> n >> W >> B >> X;
    vector<ll> c(n);
    vector<ll> cost(n);
    for (int i = 0; i < n; i++) {
        cin >> c[i];
    }
    for (int i = 0; i < n; i++) {
        cin >> cost[i];
    }

    vector<ll> dp(maxapple + 1, -1);
    dp[0] = W;
    int tot = 0;

    for (int i = 0; i < n; i++) {
        int ntot = min(tot + (int)c[i], maxapple);
        vector<ll> ndp(maxapple + 1, -1);
        deque<int> q;

        for (int j = 0; j <= ntot; j++) {
        ll L = (ll)j - c[i];
        while (!q.empty() && q.front() < L) {
            q.pop_front();
        }

        if (j <= tot && dp[j] != -1) {
            ll ce = dp[j] + X;
            ll me = W + B * (ll)j;
            ll gval = min(ce, me) + (ll)j * cost[i];
            while (!q.empty()) {
            int idx = q.back();
            ll cei = dp[idx] + X;
            ll mei = W + B * (ll)idx;
            ll gidx = min(cei, mei) + (ll)idx * cost[i];
            if (gidx <= gval) {
                q.pop_back();
            } else {
                break;
            }
            }
            q.push_back(j);
        }

        if (!q.empty()) {
            int idx = q.front();
            ll cei = dp[idx] + X;
            ll mei = W + B * (ll)idx;
            ll g = min(cei, mei) + (ll)idx * cost[i];
            ndp[j] = g - (ll)j * cost[i];
            if (ndp[j] < 0) {
            ndp[j] = -1;
            }
        } else {
            ndp[j] = -1;
        }
        }

        dp = ndp;
        tot = ntot;
    }

    int ans = 0;
    for (int j = tot; j >= 0; j--) {
        if (dp[j] >= 0) {
        ans = j;
        break;
        }
    }
    cout << ans << endl;

    return 0;
}

/*


使用dp[j]表示摘取j个苹果后的剩余能量（状态需满足能量非负）。状态转移时，考虑在第i棵树上摘取k个苹果，需确保当前能量足够消耗，并更新剩余能量和能量上限。

单调队列优化：对于每棵树，使用单调队列高效计算状态转移。队列维护一个滑动窗口内的最大值，确保每次状态转移在常数时间内完成，从而将总复杂度优化至O(n
* tot_apples)，其中tot_apples是苹果总数上限（10000）。

关键步骤：

初始化dp[0] = W（起始能量）。

遍历每棵树，更新状态：

计算新状态ndp[j]，表示在当前树摘完苹果后的剩余能量。

使用单调队列维护窗口[j - c_i, j]内的最大值，快速计算ndp[j]。

更新dp为ndp，并累计苹果总数。

最终遍历dp数组，找到最大j使得dp[j] >= 0。

*/